+Sun Feb 7 19:49:21 1999 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwindow.c (gtk_window_move_resize): Fixed some
+ bugs with set_default_size.
+
+Sat Feb 6 13:23:51 1999 Owen Taylor <otaylor@redhat.com>
+
+ * docs/Changes-1.2.txt: Added information about
+ the change to gtk_widget_size_request().
+
+ * gtk/gtkentry.c: Call gtk_widget_get_child_requisition
+ explicitely since we differentiate between the usize
+ set by the user and what we got. (Ugh)
+
+ * gtk/gtkwidget.[ch] (gtk_widget_get_child_requisition):
+ New function to return the effective size of a widget
+ as it looks to its parent.
+
+ * gtk/gtkwidget.c (gtk_widget_size_request): Leave
+ widget->requisition set to exactly what the widget
+ asked for, and then make a copy of that into
+ the requisition argument. Allow a NULL requisition
+ argument, and, if G_ENABLE_DEBUG, warn if
+ requisition == &widget->requisition.
+
+ * gtkalignment.c gtkaspectframe.c gtkbutton.c gtkclist.c
+ gtkcontainer.c gtkentry.c gtkeventbox.c gtkfixed.c
+ gtkframe.c gtkhandlebox.c gtkhbox.c gtkhpaned.c
+ gtklayout.c gtklist.c gtklistitem.c gtkmenu.c
+ gtkmenubar.c gtkmenuitem.c gtknotebook.c
+ gtkoptionmenu.c gtkpacker.c gtkscrolledwindow.c
+ gtktable.c gtktoolbar.c gtktree.c gtktreeitem.c
+ gtkvbox.c gtkviewport.c gtkvpaned.c gtkwindow.c
+
+ Avoid calling gtk_widget_size_request with
+ requisition == widget->requisition; use
+ gtk_widget_get_child_requisition to get the
+ size of children.
+
Tue Feb 9 19:49:46 1999 Owen Taylor <otaylor@redhat.com>
* configure.in (LDFLAGS): Removed extraneous line
* Makefile.am: update to include the latest Tutorial examples.
+>>>>>>> 1.1009
Sat Feb 6 11:20:16 1999 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.c (gtk_widget_idle_draw): Add the
+Sun Feb 7 19:49:21 1999 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwindow.c (gtk_window_move_resize): Fixed some
+ bugs with set_default_size.
+
+Sat Feb 6 13:23:51 1999 Owen Taylor <otaylor@redhat.com>
+
+ * docs/Changes-1.2.txt: Added information about
+ the change to gtk_widget_size_request().
+
+ * gtk/gtkentry.c: Call gtk_widget_get_child_requisition
+ explicitely since we differentiate between the usize
+ set by the user and what we got. (Ugh)
+
+ * gtk/gtkwidget.[ch] (gtk_widget_get_child_requisition):
+ New function to return the effective size of a widget
+ as it looks to its parent.
+
+ * gtk/gtkwidget.c (gtk_widget_size_request): Leave
+ widget->requisition set to exactly what the widget
+ asked for, and then make a copy of that into
+ the requisition argument. Allow a NULL requisition
+ argument, and, if G_ENABLE_DEBUG, warn if
+ requisition == &widget->requisition.
+
+ * gtkalignment.c gtkaspectframe.c gtkbutton.c gtkclist.c
+ gtkcontainer.c gtkentry.c gtkeventbox.c gtkfixed.c
+ gtkframe.c gtkhandlebox.c gtkhbox.c gtkhpaned.c
+ gtklayout.c gtklist.c gtklistitem.c gtkmenu.c
+ gtkmenubar.c gtkmenuitem.c gtknotebook.c
+ gtkoptionmenu.c gtkpacker.c gtkscrolledwindow.c
+ gtktable.c gtktoolbar.c gtktree.c gtktreeitem.c
+ gtkvbox.c gtkviewport.c gtkvpaned.c gtkwindow.c
+
+ Avoid calling gtk_widget_size_request with
+ requisition == widget->requisition; use
+ gtk_widget_get_child_requisition to get the
+ size of children.
+
Tue Feb 9 19:49:46 1999 Owen Taylor <otaylor@redhat.com>
* configure.in (LDFLAGS): Removed extraneous line
* Makefile.am: update to include the latest Tutorial examples.
+>>>>>>> 1.1009
Sat Feb 6 11:20:16 1999 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.c (gtk_widget_idle_draw): Add the
+Sun Feb 7 19:49:21 1999 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwindow.c (gtk_window_move_resize): Fixed some
+ bugs with set_default_size.
+
+Sat Feb 6 13:23:51 1999 Owen Taylor <otaylor@redhat.com>
+
+ * docs/Changes-1.2.txt: Added information about
+ the change to gtk_widget_size_request().
+
+ * gtk/gtkentry.c: Call gtk_widget_get_child_requisition
+ explicitely since we differentiate between the usize
+ set by the user and what we got. (Ugh)
+
+ * gtk/gtkwidget.[ch] (gtk_widget_get_child_requisition):
+ New function to return the effective size of a widget
+ as it looks to its parent.
+
+ * gtk/gtkwidget.c (gtk_widget_size_request): Leave
+ widget->requisition set to exactly what the widget
+ asked for, and then make a copy of that into
+ the requisition argument. Allow a NULL requisition
+ argument, and, if G_ENABLE_DEBUG, warn if
+ requisition == &widget->requisition.
+
+ * gtkalignment.c gtkaspectframe.c gtkbutton.c gtkclist.c
+ gtkcontainer.c gtkentry.c gtkeventbox.c gtkfixed.c
+ gtkframe.c gtkhandlebox.c gtkhbox.c gtkhpaned.c
+ gtklayout.c gtklist.c gtklistitem.c gtkmenu.c
+ gtkmenubar.c gtkmenuitem.c gtknotebook.c
+ gtkoptionmenu.c gtkpacker.c gtkscrolledwindow.c
+ gtktable.c gtktoolbar.c gtktree.c gtktreeitem.c
+ gtkvbox.c gtkviewport.c gtkvpaned.c gtkwindow.c
+
+ Avoid calling gtk_widget_size_request with
+ requisition == widget->requisition; use
+ gtk_widget_get_child_requisition to get the
+ size of children.
+
Tue Feb 9 19:49:46 1999 Owen Taylor <otaylor@redhat.com>
* configure.in (LDFLAGS): Removed extraneous line
* Makefile.am: update to include the latest Tutorial examples.
+>>>>>>> 1.1009
Sat Feb 6 11:20:16 1999 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.c (gtk_widget_idle_draw): Add the
+Sun Feb 7 19:49:21 1999 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwindow.c (gtk_window_move_resize): Fixed some
+ bugs with set_default_size.
+
+Sat Feb 6 13:23:51 1999 Owen Taylor <otaylor@redhat.com>
+
+ * docs/Changes-1.2.txt: Added information about
+ the change to gtk_widget_size_request().
+
+ * gtk/gtkentry.c: Call gtk_widget_get_child_requisition
+ explicitely since we differentiate between the usize
+ set by the user and what we got. (Ugh)
+
+ * gtk/gtkwidget.[ch] (gtk_widget_get_child_requisition):
+ New function to return the effective size of a widget
+ as it looks to its parent.
+
+ * gtk/gtkwidget.c (gtk_widget_size_request): Leave
+ widget->requisition set to exactly what the widget
+ asked for, and then make a copy of that into
+ the requisition argument. Allow a NULL requisition
+ argument, and, if G_ENABLE_DEBUG, warn if
+ requisition == &widget->requisition.
+
+ * gtkalignment.c gtkaspectframe.c gtkbutton.c gtkclist.c
+ gtkcontainer.c gtkentry.c gtkeventbox.c gtkfixed.c
+ gtkframe.c gtkhandlebox.c gtkhbox.c gtkhpaned.c
+ gtklayout.c gtklist.c gtklistitem.c gtkmenu.c
+ gtkmenubar.c gtkmenuitem.c gtknotebook.c
+ gtkoptionmenu.c gtkpacker.c gtkscrolledwindow.c
+ gtktable.c gtktoolbar.c gtktree.c gtktreeitem.c
+ gtkvbox.c gtkviewport.c gtkvpaned.c gtkwindow.c
+
+ Avoid calling gtk_widget_size_request with
+ requisition == widget->requisition; use
+ gtk_widget_get_child_requisition to get the
+ size of children.
+
Tue Feb 9 19:49:46 1999 Owen Taylor <otaylor@redhat.com>
* configure.in (LDFLAGS): Removed extraneous line
* Makefile.am: update to include the latest Tutorial examples.
+>>>>>>> 1.1009
Sat Feb 6 11:20:16 1999 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.c (gtk_widget_idle_draw): Add the
+Sun Feb 7 19:49:21 1999 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwindow.c (gtk_window_move_resize): Fixed some
+ bugs with set_default_size.
+
+Sat Feb 6 13:23:51 1999 Owen Taylor <otaylor@redhat.com>
+
+ * docs/Changes-1.2.txt: Added information about
+ the change to gtk_widget_size_request().
+
+ * gtk/gtkentry.c: Call gtk_widget_get_child_requisition
+ explicitely since we differentiate between the usize
+ set by the user and what we got. (Ugh)
+
+ * gtk/gtkwidget.[ch] (gtk_widget_get_child_requisition):
+ New function to return the effective size of a widget
+ as it looks to its parent.
+
+ * gtk/gtkwidget.c (gtk_widget_size_request): Leave
+ widget->requisition set to exactly what the widget
+ asked for, and then make a copy of that into
+ the requisition argument. Allow a NULL requisition
+ argument, and, if G_ENABLE_DEBUG, warn if
+ requisition == &widget->requisition.
+
+ * gtkalignment.c gtkaspectframe.c gtkbutton.c gtkclist.c
+ gtkcontainer.c gtkentry.c gtkeventbox.c gtkfixed.c
+ gtkframe.c gtkhandlebox.c gtkhbox.c gtkhpaned.c
+ gtklayout.c gtklist.c gtklistitem.c gtkmenu.c
+ gtkmenubar.c gtkmenuitem.c gtknotebook.c
+ gtkoptionmenu.c gtkpacker.c gtkscrolledwindow.c
+ gtktable.c gtktoolbar.c gtktree.c gtktreeitem.c
+ gtkvbox.c gtkviewport.c gtkvpaned.c gtkwindow.c
+
+ Avoid calling gtk_widget_size_request with
+ requisition == widget->requisition; use
+ gtk_widget_get_child_requisition to get the
+ size of children.
+
Tue Feb 9 19:49:46 1999 Owen Taylor <otaylor@redhat.com>
* configure.in (LDFLAGS): Removed extraneous line
* Makefile.am: update to include the latest Tutorial examples.
+>>>>>>> 1.1009
Sat Feb 6 11:20:16 1999 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.c (gtk_widget_idle_draw): Add the
+Sun Feb 7 19:49:21 1999 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwindow.c (gtk_window_move_resize): Fixed some
+ bugs with set_default_size.
+
+Sat Feb 6 13:23:51 1999 Owen Taylor <otaylor@redhat.com>
+
+ * docs/Changes-1.2.txt: Added information about
+ the change to gtk_widget_size_request().
+
+ * gtk/gtkentry.c: Call gtk_widget_get_child_requisition
+ explicitely since we differentiate between the usize
+ set by the user and what we got. (Ugh)
+
+ * gtk/gtkwidget.[ch] (gtk_widget_get_child_requisition):
+ New function to return the effective size of a widget
+ as it looks to its parent.
+
+ * gtk/gtkwidget.c (gtk_widget_size_request): Leave
+ widget->requisition set to exactly what the widget
+ asked for, and then make a copy of that into
+ the requisition argument. Allow a NULL requisition
+ argument, and, if G_ENABLE_DEBUG, warn if
+ requisition == &widget->requisition.
+
+ * gtkalignment.c gtkaspectframe.c gtkbutton.c gtkclist.c
+ gtkcontainer.c gtkentry.c gtkeventbox.c gtkfixed.c
+ gtkframe.c gtkhandlebox.c gtkhbox.c gtkhpaned.c
+ gtklayout.c gtklist.c gtklistitem.c gtkmenu.c
+ gtkmenubar.c gtkmenuitem.c gtknotebook.c
+ gtkoptionmenu.c gtkpacker.c gtkscrolledwindow.c
+ gtktable.c gtktoolbar.c gtktree.c gtktreeitem.c
+ gtkvbox.c gtkviewport.c gtkvpaned.c gtkwindow.c
+
+ Avoid calling gtk_widget_size_request with
+ requisition == widget->requisition; use
+ gtk_widget_get_child_requisition to get the
+ size of children.
+
Tue Feb 9 19:49:46 1999 Owen Taylor <otaylor@redhat.com>
* configure.in (LDFLAGS): Removed extraneous line
* Makefile.am: update to include the latest Tutorial examples.
+>>>>>>> 1.1009
Sat Feb 6 11:20:16 1999 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.c (gtk_widget_idle_draw): Add the
+Sun Feb 7 19:49:21 1999 Owen Taylor <otaylor@redhat.com>
+
+ * gtk/gtkwindow.c (gtk_window_move_resize): Fixed some
+ bugs with set_default_size.
+
+Sat Feb 6 13:23:51 1999 Owen Taylor <otaylor@redhat.com>
+
+ * docs/Changes-1.2.txt: Added information about
+ the change to gtk_widget_size_request().
+
+ * gtk/gtkentry.c: Call gtk_widget_get_child_requisition
+ explicitely since we differentiate between the usize
+ set by the user and what we got. (Ugh)
+
+ * gtk/gtkwidget.[ch] (gtk_widget_get_child_requisition):
+ New function to return the effective size of a widget
+ as it looks to its parent.
+
+ * gtk/gtkwidget.c (gtk_widget_size_request): Leave
+ widget->requisition set to exactly what the widget
+ asked for, and then make a copy of that into
+ the requisition argument. Allow a NULL requisition
+ argument, and, if G_ENABLE_DEBUG, warn if
+ requisition == &widget->requisition.
+
+ * gtkalignment.c gtkaspectframe.c gtkbutton.c gtkclist.c
+ gtkcontainer.c gtkentry.c gtkeventbox.c gtkfixed.c
+ gtkframe.c gtkhandlebox.c gtkhbox.c gtkhpaned.c
+ gtklayout.c gtklist.c gtklistitem.c gtkmenu.c
+ gtkmenubar.c gtkmenuitem.c gtknotebook.c
+ gtkoptionmenu.c gtkpacker.c gtkscrolledwindow.c
+ gtktable.c gtktoolbar.c gtktree.c gtktreeitem.c
+ gtkvbox.c gtkviewport.c gtkvpaned.c gtkwindow.c
+
+ Avoid calling gtk_widget_size_request with
+ requisition == widget->requisition; use
+ gtk_widget_get_child_requisition to get the
+ size of children.
+
Tue Feb 9 19:49:46 1999 Owen Taylor <otaylor@redhat.com>
* configure.in (LDFLAGS): Removed extraneous line
* Makefile.am: update to include the latest Tutorial examples.
+>>>>>>> 1.1009
Sat Feb 6 11:20:16 1999 Owen Taylor <otaylor@redhat.com>
* gtk/gtkwidget.c (gtk_widget_idle_draw): Add the
You can get these CFLAGS and LIBS by passing gthread
as the fourth parameter to the AM_PATH_GTK automake
macro.
+
+* Prior to GTK+-1.2, there were two conflicting interpretations
+ of widget->requistion. It was either taken to be
+ the size that the widget requested, or that size
+ modified by calls to gtk_widget_set_usize(). In GTK+-1.2,
+ it is always interpreted the first way.
+
+ Container widgets are affected in two ways by this:
+
+ 1) Container widgets should not pass widget->requisition
+ as the second parameter to gtk_widget_size_request().
+ Instead they should call it like:
+
+ GtkRequisition child_requisition;
+ gtk_widget_size_request (widget, &child_requisition);
+
+ 2) Container widgets should not access child->requisition
+ directly. Either they should use the values returned
+ by gtk_widget_size_request(), or they should call
+ the new function:
+
+ void gtk_widget_get_child_requisition (GtkWidget *widget,
+ GtkRequisition *requisition);
+
+ which returns the requisition of the given widget, modified
+ by calls to gtk_widget_set_usize().
+
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
- gtk_widget_size_request (bin->child, &bin->child->requisition);
+ GtkRequisition child_requisition;
+
+ gtk_widget_size_request (bin->child, &child_requisition);
- requisition->width += bin->child->requisition.width;
- requisition->height += bin->child->requisition.height;
+ requisition->width += child_requisition.width;
+ requisition->height += child_requisition.height;
}
}
GtkAlignment *alignment;
GtkBin *bin;
GtkAllocation child_allocation;
+ GtkRequisition child_requisition;
gint width, height;
gint x, y;
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
+ gtk_widget_get_child_requisition (bin->child, &child_requisition);
+
x = GTK_CONTAINER (alignment)->border_width;
y = GTK_CONTAINER (alignment)->border_width;
width = MAX (allocation->width - 2 * x, 0);
height = MAX (allocation->height - 2 * y, 0);
- if (width > bin->child->requisition.width)
- child_allocation.width = (bin->child->requisition.width *
+ if (width > child_requisition.width)
+ child_allocation.width = (child_requisition.width *
(1.0 - alignment->xscale) +
width * alignment->xscale);
else
child_allocation.width = width;
- if (height > bin->child->requisition.height)
- child_allocation.height = (bin->child->requisition.height *
+ if (height > child_requisition.height)
+ child_allocation.height = (child_requisition.height *
(1.0 - alignment->yscale) +
height * alignment->yscale);
else
{
if (aspect_frame->obey_child)
{
- if (bin->child->requisition.height != 0)
+ GtkRequisition child_requisition;
+
+ gtk_widget_get_child_requisition (bin->child, &child_requisition);
+ if (child_requisition.height != 0)
{
- ratio = (gdouble)bin->child->requisition.width /
- bin->child->requisition.height;
+ ratio = (gdouble)child_requisition.width /
+ child_requisition.height;
if (ratio < MIN_RATIO) ratio = MIN_RATIO;
}
- else if (bin->child->requisition.width != 0)
+ else if (child_requisition.width != 0)
ratio = MAX_RATIO;
else
ratio = 1.0;
if (GTK_BIN (button)->child && GTK_WIDGET_VISIBLE (GTK_BIN (button)->child))
{
- gtk_widget_size_request (GTK_BIN (button)->child, >K_BIN (button)->child->requisition);
+ GtkRequisition child_requisition;
- requisition->width += GTK_BIN (button)->child->requisition.width;
- requisition->height += GTK_BIN (button)->child->requisition.height;
+ gtk_widget_size_request (GTK_BIN (button)->child, &child_requisition);
+
+ requisition->width += child_requisition.width;
+ requisition->height += child_requisition.height;
}
}
for (i = 0; i < clist->columns; i++)
if (clist->column[i].button)
{
+ GtkRequisition child_requisition;
+
gtk_widget_size_request (clist->column[i].button,
- &clist->column[i].button->requisition);
+ &child_requisition);
clist->column_title_area.height =
MAX (clist->column_title_area.height,
- clist->column[i].button->requisition.height);
+ child_requisition.height);
}
requisition->width += (widget->style->klass->xthickness +
if (!block_resize && (!clist->vadjustment || !clist->hadjustment))
{
GtkWidget *widget;
+ GtkRequisition requisition;
widget = GTK_WIDGET (clist);
- gtk_widget_size_request (widget, &widget->requisition);
+ gtk_widget_size_request (widget, &requisition);
if ((!clist->hadjustment &&
- widget->requisition.width != widget->allocation.width) ||
+ requisition.width != widget->allocation.width) ||
(!clist->vadjustment &&
- widget->requisition.height != widget->allocation.height))
+ requisition.height != widget->allocation.height))
gtk_widget_queue_resize (widget);
}
}
gtk_container_real_check_resize (GtkContainer *container)
{
GtkWidget *widget;
+ GtkRequisition requisition;
g_return_if_fail (container != NULL);
g_return_if_fail (GTK_IS_CONTAINER (container));
widget = GTK_WIDGET (container);
- gtk_widget_size_request (widget, &widget->requisition);
+ gtk_widget_size_request (widget, &requisition);
- if (widget->requisition.width > widget->allocation.width ||
- widget->requisition.height > widget->allocation.height)
+ if (requisition.width > widget->allocation.width ||
+ requisition.height > widget->allocation.height)
{
if (GTK_IS_RESIZE_CONTAINER (container))
gtk_widget_size_allocate (GTK_WIDGET (container),
{
GtkEntry *entry;
GtkEditable *editable;
+ GtkRequisition requisition;
GdkWindowAttr attributes;
gint attributes_mask;
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
entry = GTK_ENTRY (widget);
editable = GTK_EDITABLE (widget);
+
+ gtk_widget_get_child_requisition (widget, &requisition);
attributes.window_type = GDK_WINDOW_CHILD;
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y + (widget->allocation.height -
- widget->requisition.height) / 2;
+ requisition.height) / 2;
attributes.width = widget->allocation.width;
- attributes.height = widget->requisition.height;
+ attributes.height = requisition.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes.x = widget->style->klass->xthickness;
attributes.y = widget->style->klass->ythickness;
attributes.width = widget->allocation.width - attributes.x * 2;
- attributes.height = widget->requisition.height - attributes.y * 2;
+ attributes.height = requisition.height - attributes.y * 2;
attributes.cursor = entry->cursor = gdk_cursor_new (GDK_XTERM);
attributes_mask |= GDK_WA_CURSOR;
if (GTK_WIDGET_REALIZED (widget))
{
+ /* We call gtk_widget_get_child_requisition, since we want (for
+ * backwards compatibility reasons) the realization here to
+ * be affected by the usize of the entry, if set
+ */
+ GtkRequisition requisition;
+ gtk_widget_get_child_requisition (widget, &requisition);
+
gdk_window_move_resize (widget->window,
allocation->x,
- allocation->y + (allocation->height - widget->requisition.height) / 2,
- allocation->width, widget->requisition.height);
+ allocation->y + (allocation->height - requisition.height) / 2,
+ allocation->width, requisition.height);
gdk_window_move_resize (entry->text_area,
widget->style->klass->xthickness,
widget->style->klass->ythickness,
allocation->width - widget->style->klass->xthickness * 2,
- widget->requisition.height - widget->style->klass->ythickness * 2);
+ requisition.height - widget->style->klass->ythickness * 2);
/* And make sure the cursor is on screen */
entry_adjust_scroll (entry);
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
- gtk_widget_size_request (bin->child, &bin->child->requisition);
+ GtkRequisition child_requisition;
+
+ gtk_widget_size_request (bin->child, &child_requisition);
- requisition->width += bin->child->requisition.width;
- requisition->height += bin->child->requisition.height;
+ requisition->width += child_requisition.width;
+ requisition->height += child_requisition.height;
}
}
GtkFixed *fixed;
GtkFixedChild *child;
GList *children;
+ GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_FIXED (widget));
if (GTK_WIDGET_VISIBLE (child->widget))
{
- gtk_widget_size_request (child->widget, &child->widget->requisition);
+ gtk_widget_size_request (child->widget, &child_requisition);
requisition->height = MAX (requisition->height,
child->y +
- child->widget->requisition.height);
+ child_requisition.height);
requisition->width = MAX (requisition->width,
child->x +
- child->widget->requisition.width);
+ child_requisition.width);
}
}
GtkFixed *fixed;
GtkFixedChild *child;
GtkAllocation child_allocation;
+ GtkRequisition child_requisition;
GList *children;
guint16 border_width;
if (GTK_WIDGET_VISIBLE (child->widget))
{
+ gtk_widget_get_child_requisition (child->widget, &child_requisition);
child_allocation.x = child->x + border_width;
child_allocation.y = child->y + border_width;
- child_allocation.width = child->widget->requisition.width;
- child_allocation.height = child->widget->requisition.height;
+ child_allocation.width = child_requisition.width;
+ child_allocation.height = child_requisition.height;
gtk_widget_size_allocate (child->widget, &child_allocation);
}
}
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
- gtk_widget_size_request (bin->child, &bin->child->requisition);
+ GtkRequisition child_requisition;
+
+ gtk_widget_size_request (bin->child, &child_requisition);
- requisition->width += MAX (bin->child->requisition.width, frame->label_width);
- requisition->height += bin->child->requisition.height;
+ requisition->width += MAX (child_requisition.width, frame->label_width);
+ requisition->height += child_requisition.height;
}
else
{
{
GtkBin *bin;
GtkHandleBox *hb;
+ GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_HANDLE_BOX (widget));
* won't have any usefull hint for our size otherwise.
*/
if (bin->child)
- gtk_widget_size_request (bin->child, &bin->child->requisition);
+ gtk_widget_size_request (bin->child, &child_requisition);
if (hb->child_detached)
{
{
if (hb->handle_position == GTK_POS_LEFT ||
hb->handle_position == GTK_POS_RIGHT)
- requisition->height += bin->child->requisition.height;
+ requisition->height += child_requisition.height;
else
- requisition->width += bin->child->requisition.width;
+ requisition->width += child_requisition.width;
}
else
{
if (bin->child)
{
- requisition->width += bin->child->requisition.width;
- requisition->height += bin->child->requisition.height;
+ requisition->width += child_requisition.width;
+ requisition->height += child_requisition.height;
}
else
{
{
GtkBin *bin;
GtkHandleBox *hb;
+ GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_HANDLE_BOX (widget));
widget->allocation.x = allocation->x;
+ if (bin->child)
+ gtk_widget_get_child_requisition (bin->child, &child_requisition);
+ else
+ {
+ child_requisition.width = 0;
+ child_requisition.height = 0;
+ }
+
if (hb->child_detached)
{
guint max_req_height;
guint max_req_width;
max_req_height = MAX (widget->requisition.height,
- bin->child->requisition.height +
+ child_requisition.height +
2 * widget->style->klass->ythickness);
max_req_width = MAX (widget->requisition.width,
- bin->child->requisition.width +
+ child_requisition.width +
2 * widget->style->klass->xthickness);
if (allocation->height > max_req_height)
guint float_width;
guint float_height;
- child_allocation.width = child->requisition.width;
- child_allocation.height = child->requisition.height;
+ child_allocation.width = child_requisition.width;
+ child_allocation.height = child_requisition.height;
float_width = child_allocation.width + 2 * border_width;
float_height = child_allocation.height + 2 * border_width;
guint in_drag : 1;
guint shrink_on_detach : 1;
- gint dragoff_x, dragoff_y; /* start drag position (wrt widget->window) */
+ /* Variables used during a drag
+ */
+ gint dragoff_x, dragoff_y; /* offset from event->root_x/y and
+ * attach point on float */
+ gint deskoff_x, deskoff_y; /* Offset between root relative coordinates
+ * and deskrelative coordinates */
+ gint attach_x, attach_y; /* Root relative-coordinates of attach
+ * point on widget->window */
};
struct _GtkHandleBoxClass
if (GTK_WIDGET_VISIBLE (child->widget))
{
- gtk_widget_size_request (child->widget, &child->widget->requisition);
+ GtkRequisition child_requisition;
+
+ gtk_widget_size_request (child->widget, &child_requisition);
if (box->homogeneous)
{
- width = child->widget->requisition.width + child->padding * 2;
+ width = child_requisition.width + child->padding * 2;
requisition->width = MAX (requisition->width, width);
}
else
{
- requisition->width += child->widget->requisition.width + child->padding * 2;
+ requisition->width += child_requisition.width + child->padding * 2;
}
- requisition->height = MAX (requisition->height, child->widget->requisition.height);
+ requisition->height = MAX (requisition->height, child_requisition.height);
nvis_children += 1;
}
}
else if (nexpand_children > 0)
{
- width = (gint)allocation->width - (gint)widget->requisition.width;
+ width = (gint) allocation->width - (gint) widget->requisition.width;
extra = width / nexpand_children;
}
else
x = allocation->x + GTK_CONTAINER (box)->border_width;
child_allocation.y = allocation->y + GTK_CONTAINER (box)->border_width;
- child_allocation.height = MAX (1, (gint)allocation->height - (gint)GTK_CONTAINER (box)->border_width * 2);
+ child_allocation.height = MAX (1, (gint) allocation->height - (gint) GTK_CONTAINER (box)->border_width * 2);
children = box->children;
while (children)
}
else
{
- child_width = child->widget->requisition.width + child->padding * 2;
+ GtkRequisition child_requisition;
+
+ gtk_widget_get_child_requisition (child->widget, &child_requisition);
+
+ child_width = child_requisition.width + child->padding * 2;
if (child->expand)
{
if (child->fill)
{
- child_allocation.width = MAX (1, (gint)child_width - (gint)child->padding * 2);
+ child_allocation.width = MAX (1, (gint) child_width - (gint) child->padding * 2);
child_allocation.x = x + child->padding;
}
else
{
- child_allocation.width = child->widget->requisition.width;
+ GtkRequisition child_requisition;
+
+ gtk_widget_get_child_requisition (child->widget, &child_requisition);
+ child_allocation.width = child_requisition.width;
child_allocation.x = x + (child_width - child_allocation.width) / 2;
}
if ((child->pack == GTK_PACK_END) && GTK_WIDGET_VISIBLE (child->widget))
{
+ GtkRequisition child_requisition;
+ gtk_widget_get_child_requisition (child->widget, &child_requisition);
+
if (box->homogeneous)
{
if (nvis_children == 1)
}
else
{
- child_width = child->widget->requisition.width + child->padding * 2;
+ child_width = child_requisition.width + child->padding * 2;
if (child->expand)
{
}
else
{
- child_allocation.width = child->widget->requisition.width;
+ child_allocation.width = child_requisition.width;
child_allocation.x = x + (child_width - child_allocation.width) / 2 - child_width;
}
GtkRequisition *requisition)
{
GtkPaned *paned;
+ GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_HPANED (widget));
if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1))
{
- gtk_widget_size_request (paned->child1, &paned->child1->requisition);
+ gtk_widget_size_request (paned->child1, &child_requisition);
- requisition->height = paned->child1->requisition.height;
- requisition->width = paned->child1->requisition.width;
+ requisition->height = child_requisition.height;
+ requisition->width = child_requisition.width;
}
if (paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
{
- gtk_widget_size_request (paned->child2, &paned->child2->requisition);
+ gtk_widget_size_request (paned->child2, &child_requisition);
- requisition->height = MAX(requisition->height,
- paned->child2->requisition.height);
- requisition->width += paned->child2->requisition.width;
+ requisition->height = MAX(requisition->height, child_requisition.height);
+ requisition->width += child_requisition.width;
}
requisition->width += GTK_CONTAINER (paned)->border_width * 2 + paned->gutter_size;
GtkAllocation *allocation)
{
GtkPaned *paned;
+ GtkRequisition child1_requisition;
+ GtkRequisition child2_requisition;
GtkAllocation child1_allocation;
GtkAllocation child2_allocation;
GdkRectangle old_groove_rectangle;
paned = GTK_PANED (widget);
border_width = GTK_CONTAINER (paned)->border_width;
+ if (paned->child1)
+ gtk_widget_get_child_requisition (paned->child1, &child1_requisition);
+ else
+ child1_requisition.width = 0;
+
+ if (paned->child2)
+ gtk_widget_get_child_requisition (paned->child2, &child2_requisition);
+ else
+ child2_requisition.width = 0;
+
gtk_paned_compute_position (paned,
widget->allocation.width
- paned->gutter_size
- 2 * border_width,
- paned->child1 ? paned->child1->requisition.width : 0,
- paned->child2 ? paned->child2->requisition.width : 0);
+ child1_requisition.width,
+ child2_requisition.width);
/* Move the handle before the children so we don't get extra expose events */
child->widget = child_widget;
child->x = x;
child->y = y;
- child->widget->requisition.width = 0;
- child->widget->requisition.height = 0;
layout->children = g_list_append (layout->children, child);
while (tmp_list)
{
GtkLayoutChild *child = tmp_list->data;
+ GtkRequisition child_requisition;
+
tmp_list = tmp_list->next;
- gtk_widget_size_request (child->widget, &child->widget->requisition);
+ gtk_widget_size_request (child->widget, &child_requisition);
}
}
GtkLayoutChild *child)
{
GtkAllocation allocation;
+ GtkRequisition requisition;
allocation.x = child->x - layout->xoffset;
allocation.y = child->y - layout->yoffset;
- allocation.width = child->widget->requisition.width;
- allocation.height = child->widget->requisition.height;
+ gtk_widget_get_child_requisition (child->widget, &requisition);
+ allocation.width = requisition.width;
+ allocation.height = requisition.height;
gtk_widget_size_allocate (child->widget, &allocation);
}
if (GTK_WIDGET_VISIBLE (child))
{
- gtk_widget_size_request (child, &child->requisition);
+ GtkRequisition child_requisition;
+
+ gtk_widget_size_request (child, &child_requisition);
requisition->width = MAX (requisition->width,
- child->requisition.width);
- requisition->height += child->requisition.height;
+ child_requisition.width);
+ requisition->height += child_requisition.height;
}
}
if (GTK_WIDGET_VISIBLE (child))
{
- child_allocation.height = child->requisition.height;
+ GtkRequisition child_requisition;
+ gtk_widget_get_child_requisition (child, &child_requisition);
+
+ child_allocation.height = child_requisition.height;
gtk_widget_size_allocate (child, &child_allocation);
GtkRequisition *requisition)
{
GtkBin *bin;
+ GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_LIST_ITEM (widget));
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
- gtk_widget_size_request (bin->child, &bin->child->requisition);
+ gtk_widget_size_request (bin->child, &child_requisition);
- requisition->width += bin->child->requisition.width;
- requisition->height += bin->child->requisition.height;
+ requisition->width += child_requisition.width;
+ requisition->height += child_requisition.height;
}
}
GList *children;
guint max_toggle_size;
guint max_accel_width;
+ GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_MENU (widget));
if (GTK_WIDGET_VISIBLE (child))
{
GTK_MENU_ITEM (child)->show_submenu_indicator = TRUE;
- gtk_widget_size_request (child, &child->requisition);
+ gtk_widget_size_request (child, &child_requisition);
- requisition->width = MAX (requisition->width, child->requisition.width);
- requisition->height += child->requisition.height;
+ requisition->width = MAX (requisition->width, child_requisition.width);
+ requisition->height += child_requisition.height;
max_toggle_size = MAX (max_toggle_size, MENU_ITEM_CLASS (child)->toggle_size);
max_accel_width = MAX (max_accel_width, GTK_MENU_ITEM (child)->accelerator_width);
if (GTK_WIDGET_VISIBLE (child))
{
- child_allocation.height = child->requisition.height;
+ GtkRequisition child_requisition;
+ gtk_widget_get_child_requisition (child, &child_requisition);
+
+ child_allocation.height = child_requisition.height;
gtk_widget_size_allocate (child, &child_allocation);
gtk_widget_queue_draw (child);
gtk_menu_position (GtkMenu *menu)
{
GtkWidget *widget;
+ GtkRequisition requisition;
gint x, y;
g_return_if_fail (menu != NULL);
* if one a size_request was queued while we weren't popped up,
* the requisition won't have been recomputed yet.
*/
- gtk_widget_size_request (widget, &widget->requisition);
+ gtk_widget_size_request (widget, &requisition);
if (menu->position_func)
(* menu->position_func) (menu, &x, &y, menu->position_func_data);
x -= 2;
y -= 2;
- if ((x + widget->requisition.width) > screen_width)
- x -= ((x + widget->requisition.width) - screen_width);
+ if ((x + requisition.width) > screen_width)
+ x -= ((x + requisition.width) - screen_width);
if (x < 0)
x = 0;
- if ((y + widget->requisition.height) > screen_height)
- y -= ((y + widget->requisition.height) - screen_height);
+ if ((y + requisition.height) > screen_height)
+ y -= ((y + requisition.height) - screen_height);
if (y < 0)
y = 0;
}
GtkWidget *child;
GList *children;
gint nchildren;
+ GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_MENU_BAR (widget));
if (GTK_WIDGET_VISIBLE (child))
{
GTK_MENU_ITEM (child)->show_submenu_indicator = FALSE;
- gtk_widget_size_request (child, &child->requisition);
+ gtk_widget_size_request (child, &child_requisition);
- requisition->width += child->requisition.width;
- requisition->height = MAX (requisition->height, child->requisition.height);
+ requisition->width += child_requisition.width;
+ requisition->height = MAX (requisition->height, child_requisition.height);
/* Support for the right justified help menu */
- if ( (children == NULL) && (GTK_IS_MENU_ITEM(child))
- && (GTK_MENU_ITEM(child)->right_justify))
+ if ((children == NULL) && GTK_IS_MENU_ITEM(child) &&
+ GTK_MENU_ITEM(child)->right_justify)
{
requisition->width += CHILD_SPACING;
}
GtkWidget *child;
GList *children;
GtkAllocation child_allocation;
+ GtkRequisition child_requisition;
guint offset;
g_return_if_fail (widget != NULL);
child = children->data;
children = children->next;
+ gtk_widget_get_child_requisition (child, &child_requisition);
+
/* Support for the right justified help menu */
if ( (children == NULL) && (GTK_IS_MENU_ITEM(child))
&& (GTK_MENU_ITEM(child)->right_justify))
{
child_allocation.x = allocation->width -
- child->requisition.width - CHILD_SPACING - offset;
+ child_requisition.width - CHILD_SPACING - offset;
}
if (GTK_WIDGET_VISIBLE (child))
{
- child_allocation.width = child->requisition.width;
+ child_allocation.width = child_requisition.width;
gtk_widget_size_allocate (child, &child_allocation);
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
- gtk_widget_size_request (bin->child, &bin->child->requisition);
+ GtkRequisition child_requisition;
+
+ gtk_widget_size_request (bin->child, &child_requisition);
- requisition->width += bin->child->requisition.width;
- requisition->height += bin->child->requisition.height;
+ requisition->width += child_requisition.width;
+ requisition->height += child_requisition.height;
}
if (menu_item->submenu && menu_item->show_submenu_indicator)
GtkNotebook *notebook;
GtkNotebookPage *page;
GList *children;
+ GtkRequisition child_requisition;
gboolean switch_page = FALSE;
gint vis_pages;
if (GTK_WIDGET_VISIBLE (page->child))
{
vis_pages++;
- gtk_widget_size_request (page->child, &page->child->requisition);
+ gtk_widget_size_request (page->child, &child_requisition);
widget->requisition.width = MAX (widget->requisition.width,
- page->child->requisition.width);
+ child_requisition.width);
widget->requisition.height = MAX (widget->requisition.height,
- page->child->requisition.height);
+ child_requisition.height);
if (GTK_WIDGET_MAPPED (page->child) && page != notebook->cur_page)
gtk_widget_unmap (page->child);
if (!GTK_WIDGET_VISIBLE (page->tab_label))
gtk_widget_show (page->tab_label);
- gtk_widget_size_request (page->tab_label,
- &page->tab_label->requisition);
+ gtk_widget_size_request (page->tab_label,
+ &child_requisition);
page->requisition.width =
- page->tab_label->requisition.width +
+ child_requisition.width +
2 * widget->style->klass->xthickness;
page->requisition.height =
- page->tab_label->requisition.height +
+ child_requisition.height +
2 * widget->style->klass->ythickness;
switch (notebook->tab_pos)
{
GtkWidget *widget;
GtkAllocation child_allocation;
+ GtkRequisition tab_requisition;
gint xthickness;
gint ythickness;
gint padding;
}
page->allocation = *allocation;
+ gtk_widget_get_child_requisition (page->tab_label, &tab_requisition);
if (notebook->cur_page != page)
{
{
child_allocation.x = (page->allocation.x +
(page->allocation.width -
- page->tab_label->requisition.width) / 2);
- child_allocation.width = page->tab_label->requisition.width;
+ tab_requisition.width) / 2);
+ child_allocation.width = tab_requisition.width;
}
child_allocation.y = (notebook->tab_vborder + FOCUS_WIDTH +
page->allocation.y);
{
child_allocation.y = (page->allocation.y +
(page->allocation.height -
- page->tab_label->requisition.height) / 2);
- child_allocation.height = page->tab_label->requisition.height;
+ tab_requisition.height) / 2);
+ child_allocation.height = tab_requisition.height;
}
child_allocation.x = (page->allocation.x + notebook->tab_hborder +
FOCUS_WIDTH);
gtk_option_menu_update_contents (GtkOptionMenu *option_menu)
{
GtkWidget *child;
+ GtkRequisition child_requisition;
g_return_if_fail (option_menu != NULL);
g_return_if_fail (GTK_IS_OPTION_MENU (option_menu));
gtk_widget_reparent (child, GTK_WIDGET (option_menu));
}
- gtk_widget_size_request (child, &child->requisition);
+ gtk_widget_size_request (child, &child_requisition);
gtk_widget_size_allocate (GTK_WIDGET (option_menu),
&(GTK_WIDGET (option_menu)->allocation));
{
GtkWidget *child;
GList *children;
+ GtkRequisition child_requisition;
g_return_if_fail (option_menu != NULL);
g_return_if_fail (GTK_IS_OPTION_MENU (option_menu));
if (GTK_WIDGET_VISIBLE (child))
{
- gtk_widget_size_request (child, &child->requisition);
+ gtk_widget_size_request (child, &child_requisition);
- option_menu->width = MAX (option_menu->width, child->requisition.width);
- option_menu->height = MAX (option_menu->height, child->requisition.height);
+ option_menu->width = MAX (option_menu->width, child_requisition.width);
+ option_menu->height = MAX (option_menu->height, child_requisition.height);
}
}
}
}
static void
-gtk_packer_draw (GtkWidget *widget, GdkRectangle *area)
+gtk_packer_draw (GtkWidget *widget,
+ GdkRectangle *area)
{
GtkPacker *packer;
GtkPackerChild *child;
}
static gint
-gtk_packer_expose (GtkWidget *widget, GdkEventExpose *event)
+gtk_packer_expose (GtkWidget *widget,
+ GdkEventExpose *event)
{
GtkPacker *packer;
GtkPackerChild *child;
}
static void
-gtk_packer_size_request (GtkWidget *widget, GtkRequisition *requisition)
+gtk_packer_size_request (GtkWidget *widget,
+ GtkRequisition *requisition)
{
GtkPacker *packer;
GtkContainer *container;
gint nvis_horz_children;
gint width, height;
gint maxWidth, maxHeight;
+ GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_PACKER (widget));
if (GTK_WIDGET_VISIBLE (child->widget))
{
- gtk_widget_size_request (child->widget, &child->widget->requisition);
+ GtkRequisition child_requisition;
+
+ gtk_widget_size_request (child->widget, &child_requisition);
- if((child->side == GTK_SIDE_TOP) || (child->side == GTK_SIDE_BOTTOM))
+ if ((child->side == GTK_SIDE_TOP) || (child->side == GTK_SIDE_BOTTOM))
{
maxWidth = MAX (maxWidth,
- (child->widget->requisition.width +
+ (child_requisition.width +
2 * child->border_width +
child->pad_x + child->i_pad_x +
width));
- height += (child->widget->requisition.height +
+ height += (child_requisition.height +
2 * child->border_width +
child->pad_y + child->i_pad_y);
}
else
{
maxHeight = MAX (maxHeight,
- (child->widget->requisition.height +
+ (child_requisition.height +
2 * child->border_width +
child->pad_y + child->i_pad_y +
height));
- width += (child->widget->requisition.width +
+ width += (child_requisition.width +
2 * child->border_width +
child->pad_x + child->i_pad_x);
}
}
static gint
-YExpansion (GList *children, gint cavityHeight)
+YExpansion (GList *children,
+ gint cavityHeight)
{
GList *list;
GtkPackerChild *child;
list = children;
while (list != NULL)
{
+ GtkRequisition child_requisition;
+
child = list->data;
widget = child->widget;
- childHeight = (widget->requisition.height +
+ gtk_widget_get_child_requisition (widget, &child_requisition);
+
+ childHeight = (child_requisition.height +
2 * child->border_width +
child->i_pad_y +
child->pad_y);
}
static gint
-XExpansion (GList *children, gint cavityWidth)
+XExpansion (GList *children,
+ gint cavityWidth)
{
GList *list;
GtkPackerChild *child;
list = children;
while (list != NULL)
{
+ GtkRequisition child_requisition;
+
child = list->data;
widget = child->widget;
- childWidth = (widget->requisition.width +
+ gtk_widget_get_child_requisition (widget, &child_requisition);
+
+ childWidth = (child_requisition.width +
2 * child->border_width +
child->i_pad_x +
child->pad_x);
}
static void
-gtk_packer_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
+gtk_packer_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
{
GtkPacker *packer;
GtkContainer *container;
list = g_list_first (packer->children);
while (list != NULL)
{
+ GtkRequisition child_requisition;
+
child = list->data;
+ gtk_widget_get_child_requisition (child->widget, &child_requisition);
if ((child->side == GTK_SIDE_TOP) || (child->side == GTK_SIDE_BOTTOM))
{
frameWidth = cavityWidth;
- frameHeight = (child->widget->requisition.height +
+ frameHeight = (child_requisition.height +
2 * child->border_width +
child->pad_y +
child->i_pad_y);
else
{
frameHeight = cavityHeight;
- frameWidth = (child->widget->requisition.width +
+ frameWidth = (child_requisition.width +
2 * child->border_width +
child->pad_x +
child->i_pad_x);
borderX = child->pad_x + 2 * child->border_width;
borderY = child->pad_y + 2 * child->border_width;
- width = (child->widget->requisition.width +
+ width = (child_requisition.width +
2 * child->border_width +
child->i_pad_x);
if ((child->options & GTK_FILL_X) || (width > (frameWidth - borderX)))
width = frameWidth - borderX;
- height = (child->widget->requisition.height +
+ height = (child_requisition.height +
2 * child->border_width +
child->i_pad_y);
if ((child->options & GTK_FILL_Y) || (height > (frameHeight - borderY)))
GtkBin *bin;
gint extra_height;
gint extra_width;
+ GtkRequisition hscrollbar_requisition;
+ GtkRequisition vscrollbar_requisition;
+ GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
requisition->height = 0;
gtk_widget_size_request (scrolled_window->hscrollbar,
- &scrolled_window->hscrollbar->requisition);
+ &hscrollbar_requisition);
gtk_widget_size_request (scrolled_window->vscrollbar,
- &scrolled_window->vscrollbar->requisition);
+ &vscrollbar_requisition);
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
if (!quark_aux_info)
quark_aux_info = g_quark_from_static_string ("gtk-aux-info");
- gtk_widget_size_request (bin->child, &bin->child->requisition);
+ gtk_widget_size_request (bin->child, &child_requisition);
if (scrolled_window->hscrollbar_policy == GTK_POLICY_NEVER)
- requisition->width += bin->child->requisition.width;
+ requisition->width += child_requisition.width;
else
{
GtkWidgetAuxInfo *aux_info;
if (aux_info && aux_info->width > 0)
requisition->width += aux_info->width;
else
- requisition->width += scrolled_window->vscrollbar->requisition.width;
+ requisition->width += vscrollbar_requisition.width;
}
if (scrolled_window->vscrollbar_policy == GTK_POLICY_NEVER)
- requisition->height += bin->child->requisition.height;
+ requisition->height += child_requisition.height;
else
{
GtkWidgetAuxInfo *aux_info;
if (aux_info && aux_info->height > 0)
requisition->height += aux_info->height;
else
- requisition->height += scrolled_window->hscrollbar->requisition.height;
+ requisition->height += hscrollbar_requisition.height;
}
}
if ((scrolled_window->hscrollbar_policy == GTK_POLICY_AUTOMATIC) ||
GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar))
{
- requisition->width = MAX (requisition->width, scrolled_window->hscrollbar->requisition.width);
- extra_height = SCROLLBAR_SPACING (scrolled_window) + scrolled_window->hscrollbar->requisition.height;
+ requisition->width = MAX (requisition->width, hscrollbar_requisition.width);
+ extra_height = SCROLLBAR_SPACING (scrolled_window) + hscrollbar_requisition.height;
}
if ((scrolled_window->vscrollbar_policy == GTK_POLICY_AUTOMATIC) ||
GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar))
{
- requisition->height = MAX (requisition->height, scrolled_window->vscrollbar->requisition.height);
- extra_width = SCROLLBAR_SPACING (scrolled_window) + scrolled_window->vscrollbar->requisition.width;
+ requisition->height = MAX (requisition->height, vscrollbar_requisition.height);
+ extra_width = SCROLLBAR_SPACING (scrolled_window) + vscrollbar_requisition.width;
}
requisition->width += GTK_CONTAINER (widget)->border_width * 2 + extra_width;
if (scrolled_window->vscrollbar_visible)
{
+ GtkRequisition vscrollbar_requisition;
+ gtk_widget_get_child_requisition (scrolled_window->vscrollbar,
+ &vscrollbar_requisition);
+
if (scrolled_window->window_placement == GTK_CORNER_TOP_RIGHT ||
scrolled_window->window_placement == GTK_CORNER_BOTTOM_RIGHT)
- allocation->x += (scrolled_window->vscrollbar->requisition.width +
+ allocation->x += (vscrollbar_requisition.width +
SCROLLBAR_SPACING (scrolled_window));
allocation->width = MAX (1, (gint)allocation->width -
- ((gint)scrolled_window->vscrollbar->requisition.width +
+ ((gint)vscrollbar_requisition.width +
(gint)SCROLLBAR_SPACING (scrolled_window)));
}
if (scrolled_window->hscrollbar_visible)
{
+ GtkRequisition hscrollbar_requisition;
+ gtk_widget_get_child_requisition (scrolled_window->hscrollbar,
+ &hscrollbar_requisition);
+
if (scrolled_window->window_placement == GTK_CORNER_BOTTOM_LEFT ||
scrolled_window->window_placement == GTK_CORNER_BOTTOM_RIGHT)
- allocation->y += (scrolled_window->hscrollbar->requisition.height +
+ allocation->y += (hscrollbar_requisition.height +
SCROLLBAR_SPACING (scrolled_window));
allocation->height = MAX (1, (gint)allocation->height -
- ((gint)scrolled_window->hscrollbar->requisition.height +
+ ((gint)hscrollbar_requisition.height +
(gint)SCROLLBAR_SPACING (scrolled_window)));
}
}
if (scrolled_window->hscrollbar_visible)
{
+ GtkRequisition hscrollbar_requisition;
+ gtk_widget_get_child_requisition (scrolled_window->hscrollbar,
+ &hscrollbar_requisition);
+
if (!GTK_WIDGET_VISIBLE (scrolled_window->hscrollbar))
gtk_widget_show (scrolled_window->hscrollbar);
child_allocation.y = GTK_CONTAINER (scrolled_window)->border_width;
child_allocation.width = relative_allocation.width;
- child_allocation.height = scrolled_window->hscrollbar->requisition.height;
+ child_allocation.height = hscrollbar_requisition.height;
child_allocation.x += allocation->x;
child_allocation.y += allocation->y;
if (scrolled_window->vscrollbar_visible)
{
+ GtkRequisition vscrollbar_requisition;
if (!GTK_WIDGET_VISIBLE (scrolled_window->vscrollbar))
gtk_widget_show (scrolled_window->vscrollbar);
+ gtk_widget_get_child_requisition (scrolled_window->vscrollbar,
+ &vscrollbar_requisition);
+
if (scrolled_window->window_placement == GTK_CORNER_TOP_LEFT ||
scrolled_window->window_placement == GTK_CORNER_BOTTOM_LEFT)
child_allocation.x = (relative_allocation.x +
child_allocation.x = GTK_CONTAINER (scrolled_window)->border_width;
child_allocation.y = relative_allocation.y;
- child_allocation.width = scrolled_window->vscrollbar->requisition.width;
+ child_allocation.width = vscrollbar_requisition.width;
child_allocation.height = relative_allocation.height;
child_allocation.x += allocation->x;
child_allocation.y += allocation->y;
GdkEvent *event,
gpointer data);
+#define DEBUG_PLUGSOCKET
+
#ifdef DEBUG_PLUGSOCKET
#define DPRINTF(arg) g_print arg
#else
children = children->next;
if (GTK_WIDGET_VISIBLE (child->widget))
- gtk_widget_size_request (child->widget, &child->widget->requisition);
+ gtk_widget_size_request (child->widget, NULL);
}
}
if (GTK_WIDGET_VISIBLE (child->widget))
{
+ GtkRequisition child_requisition;
+ gtk_widget_get_child_requisition (child->widget, &child_requisition);
+
/* Child spans a single column.
*/
if (child->left_attach == (child->right_attach - 1))
{
- width = child->widget->requisition.width + child->xpadding * 2;
+ width = child_requisition.width + child->xpadding * 2;
table->cols[child->left_attach].requisition = MAX (table->cols[child->left_attach].requisition, width);
}
*/
if (child->top_attach == (child->bottom_attach - 1))
{
- height = child->widget->requisition.height + child->ypadding * 2;
+ height = child_requisition.height + child->ypadding * 2;
table->rows[child->top_attach].requisition = MAX (table->rows[child->top_attach].requisition, height);
}
}
*/
if (child->left_attach != (child->right_attach - 1))
{
+ GtkRequisition child_requisition;
+
+ gtk_widget_get_child_requisition (child->widget, &child_requisition);
+
/* Check and see if there is already enough space
* for the child.
*/
* its requisition, then divide up the needed space evenly
* amongst the columns it spans.
*/
- if (width < child->widget->requisition.width + child->xpadding * 2)
+ if (width < child_requisition.width + child->xpadding * 2)
{
- width = child->widget->requisition.width + child->xpadding * 2 - width;
+ width = child_requisition.width + child->xpadding * 2 - width;
for (col = child->left_attach; col < child->right_attach; col++)
{
*/
if (child->top_attach != (child->bottom_attach - 1))
{
+ GtkRequisition child_requisition;
+
+ gtk_widget_get_child_requisition (child->widget, &child_requisition);
+
/* Check and see if there is already enough space
* for the child.
*/
* its requisition, then divide up the needed space evenly
* amongst the columns it spans.
*/
- if (height < child->widget->requisition.height + child->ypadding * 2)
+ if (height < child_requisition.height + child->ypadding * 2)
{
- height = child->widget->requisition.height + child->ypadding * 2 - height;
+ height = child_requisition.height + child->ypadding * 2 - height;
for (row = child->top_attach; row < child->bottom_attach; row++)
{
if (GTK_WIDGET_VISIBLE (child->widget))
{
+ GtkRequisition child_requisition;
+ gtk_widget_get_child_requisition (child->widget, &child_requisition);
+
x = GTK_WIDGET (table)->allocation.x + GTK_CONTAINER (table)->border_width;
y = GTK_WIDGET (table)->allocation.y + GTK_CONTAINER (table)->border_width;
max_width = 0;
}
else
{
- allocation.width = child->widget->requisition.width;
+ allocation.width = child_requisition.width;
allocation.x = x + (max_width - allocation.width) / 2;
}
}
else
{
- allocation.height = child->widget->requisition.height;
+ allocation.height = child_requisition.height;
allocation.y = y + (max_height - allocation.height) / 2;
}
gint nbuttons;
gint button_maxw, button_maxh;
gint widget_maxw, widget_maxh;
+ GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_TOOLBAR (widget));
case GTK_TOOLBAR_CHILD_TOGGLEBUTTON:
if (GTK_WIDGET_VISIBLE (child->widget))
{
- gtk_widget_size_request (child->widget, &child->widget->requisition);
+ gtk_widget_size_request (child->widget, &child_requisition);
nbuttons++;
- button_maxw = MAX (button_maxw, child->widget->requisition.width);
- button_maxh = MAX (button_maxh, child->widget->requisition.height);
+ button_maxw = MAX (button_maxw, child_requisition.width);
+ button_maxh = MAX (button_maxh, child_requisition.height);
}
break;
case GTK_TOOLBAR_CHILD_WIDGET:
if (GTK_WIDGET_VISIBLE (child->widget))
{
- gtk_widget_size_request (child->widget, &child->widget->requisition);
+ gtk_widget_size_request (child->widget, &child_requisition);
- widget_maxw = MAX (widget_maxw, child->widget->requisition.width);
- widget_maxh = MAX (widget_maxh, child->widget->requisition.height);
+ widget_maxw = MAX (widget_maxw, child_requisition.width);
+ widget_maxh = MAX (widget_maxh, child_requisition.height);
if (toolbar->orientation == GTK_ORIENTATION_HORIZONTAL)
- requisition->width += child->widget->requisition.width;
+ requisition->width += child_requisition.width;
else
- requisition->height += child->widget->requisition.height;
+ requisition->height += child_requisition.height;
}
break;
GtkToolbarChild *child;
GtkToolbarChildSpace *child_space;
GtkAllocation alloc;
+ GtkRequisition child_requisition;
gint border_width;
g_return_if_fail (widget != NULL);
if (!GTK_WIDGET_VISIBLE (child->widget))
break;
- alloc.width = child->widget->requisition.width;
- alloc.height = child->widget->requisition.height;
+ gtk_widget_get_child_requisition (child->widget, &child_requisition);
+
+ alloc.width = child_requisition.width;
+ alloc.height = child_requisition.height;
if (toolbar->orientation == GTK_ORIENTATION_HORIZONTAL)
- alloc.y = allocation->y + (allocation->height - child->widget->requisition.height) / 2;
+ alloc.y = allocation->y + (allocation->height - child_requisition.height) / 2;
else
- alloc.x = allocation->x + (allocation->width - child->widget->requisition.width) / 2;
+ alloc.x = allocation->x + (allocation->width - child_requisition.width) / 2;
gtk_widget_size_allocate (child->widget, &alloc);
if (toolbar->orientation == GTK_ORIENTATION_HORIZONTAL)
- alloc.x += child->widget->requisition.width;
+ alloc.x += child_requisition.width;
else
- alloc.y += child->widget->requisition.height;
+ alloc.y += child_requisition.height;
break;
if (GTK_WIDGET_VISIBLE (child))
{
- child_allocation.height = child->requisition.height;
+ GtkRequisition child_requisition;
+ gtk_widget_get_child_requisition (child, &child_requisition);
+
+ child_allocation.height = child_requisition.height;
gtk_widget_size_allocate (child, &child_allocation);
GtkTree *tree;
GtkWidget *child, *subtree;
GList *children;
+ GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
if (GTK_WIDGET_VISIBLE (child))
{
- gtk_widget_size_request (child, &child->requisition);
+ gtk_widget_size_request (child, &child_requisition);
- requisition->width = MAX (requisition->width, child->requisition.width);
- requisition->height += child->requisition.height;
+ requisition->width = MAX (requisition->width, child_requisition.width);
+ requisition->height += child_requisition.height;
if((subtree = GTK_TREE_ITEM(child)->subtree) &&
GTK_WIDGET_VISIBLE (subtree))
{
- gtk_widget_size_request (subtree, &subtree->requisition);
+ gtk_widget_size_request (subtree, &child_requisition);
requisition->width = MAX (requisition->width,
- subtree->requisition.width);
+ child_requisition.width);
- requisition->height += subtree->requisition.height;
+ requisition->height += child_requisition.height;
}
}
}
{
GtkBin *bin;
GtkTreeItem* item;
+ GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_TREE_ITEM (widget));
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
- gtk_widget_size_request (bin->child, &bin->child->requisition);
+ gtk_widget_size_request (bin->child, &child_requisition);
- requisition->width += bin->child->requisition.width;
+ requisition->width += child_requisition.width;
gtk_widget_size_request (item->pixmaps_box,
&item->pixmaps_box->requisition);
requisition->width += item->pixmaps_box->requisition.width + DEFAULT_DELTA +
GTK_TREE(widget->parent)->current_indent;
- requisition->height += MAX (bin->child->requisition.height,
+ requisition->height += MAX (child_requisition.height,
item->pixmaps_box->requisition.height);
}
}
{
GtkBox *box;
GtkBoxChild *child;
+ GtkRequisition child_requisition;
GList *children;
gint nvis_children;
gint height;
if (GTK_WIDGET_VISIBLE (child->widget))
{
- gtk_widget_size_request (child->widget, &child->widget->requisition);
+ gtk_widget_size_request (child->widget, &child_requisition);
if (box->homogeneous)
{
- height = child->widget->requisition.height + child->padding * 2;
+ height = child_requisition.height + child->padding * 2;
requisition->height = MAX (requisition->height, height);
}
else
{
- requisition->height += child->widget->requisition.height + child->padding * 2;
+ requisition->height += child_requisition.height + child->padding * 2;
}
- requisition->width = MAX (requisition->width, child->widget->requisition.width);
+ requisition->width = MAX (requisition->width, child_requisition.width);
nvis_children += 1;
}
}
else if (nexpand_children > 0)
{
- height = (gint)allocation->height - (gint)widget->requisition.height;
+ height = (gint) allocation->height - (gint) widget->requisition.height;
extra = height / nexpand_children;
}
else
y = allocation->y + GTK_CONTAINER (box)->border_width;
child_allocation.x = allocation->x + GTK_CONTAINER (box)->border_width;
- child_allocation.width = MAX (1, (gint)allocation->width - (gint)GTK_CONTAINER (box)->border_width * 2);
+ child_allocation.width = MAX (1, (gint) allocation->width - (gint) GTK_CONTAINER (box)->border_width * 2);
children = box->children;
while (children)
}
else
{
- child_height = child->widget->requisition.height + child->padding * 2;
+ GtkRequisition child_requisition;
+
+ gtk_widget_get_child_requisition (child->widget, &child_requisition);
+ child_height = child_requisition.height + child->padding * 2;
if (child->expand)
{
}
else
{
- child_allocation.height = child->widget->requisition.height;
+ GtkRequisition child_requisition;
+
+ gtk_widget_get_child_requisition (child->widget, &child_requisition);
+ child_allocation.height = child_requisition.height;
child_allocation.y = y + (child_height - child_allocation.height) / 2;
}
if ((child->pack == GTK_PACK_END) && GTK_WIDGET_VISIBLE (child->widget))
{
+ GtkRequisition child_requisition;
+ gtk_widget_get_child_requisition (child->widget, &child_requisition);
+
if (box->homogeneous)
{
if (nvis_children == 1)
}
else
{
- child_height = child->widget->requisition.height + child->padding * 2;
+ child_height = child_requisition.height + child->padding * 2;
if (child->expand)
{
}
else
{
- child_allocation.height = child->widget->requisition.height;
+ child_allocation.height = child_requisition.height;
child_allocation.y = y + (child_height - child_allocation.height) / 2 - child_height;
}
{
GtkViewport *viewport;
GtkBin *bin;
+ GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_VIEWPORT (widget));
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
- gtk_widget_size_request (bin->child, &bin->child->requisition);
- requisition->width += bin->child->requisition.width;
- requisition->height += bin->child->requisition.height;
+ gtk_widget_size_request (bin->child, &child_requisition);
+ requisition->width += child_requisition.width;
+ requisition->height += child_requisition.height;
}
}
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
+ GtkRequisition child_requisition;
+ gtk_widget_get_child_requisition (bin->child, &child_requisition);
+
viewport->hadjustment->lower = 0;
- viewport->hadjustment->upper = MAX (bin->child->requisition.width,
+ viewport->hadjustment->upper = MAX (child_requisition.width,
child_allocation.width);
hval = CLAMP (hval, 0,
viewport->hadjustment->page_size);
viewport->vadjustment->lower = 0;
- viewport->vadjustment->upper = MAX (bin->child->requisition.height,
+ viewport->vadjustment->upper = MAX (child_requisition.height,
child_allocation.height);
vval = CLAMP (vval, 0,
GtkRequisition *requisition)
{
GtkPaned *paned;
+ GtkRequisition child_requisition;
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_VPANED (widget));
if (paned->child1 && GTK_WIDGET_VISIBLE (paned->child1))
{
- gtk_widget_size_request (paned->child1, &paned->child1->requisition);
+ gtk_widget_size_request (paned->child1, &child_requisition);
- requisition->height = paned->child1->requisition.height;
- requisition->width = paned->child1->requisition.width;
+ requisition->height = child_requisition.height;
+ requisition->width = child_requisition.width;
}
if (paned->child2 && GTK_WIDGET_VISIBLE (paned->child2))
{
- gtk_widget_size_request (paned->child2, &paned->child2->requisition);
+ gtk_widget_size_request (paned->child2, &child_requisition);
- requisition->width = MAX (requisition->width,
- paned->child2->requisition.width);
- requisition->height += paned->child2->requisition.height;
+ requisition->width = MAX (requisition->width, child_requisition.width);
+ requisition->height += child_requisition.height;
}
requisition->height += GTK_CONTAINER (paned)->border_width * 2 + paned->gutter_size;
GtkAllocation *allocation)
{
GtkPaned *paned;
+ GtkRequisition child1_requisition;
+ GtkRequisition child2_requisition;
GtkAllocation child1_allocation;
GtkAllocation child2_allocation;
GdkRectangle old_groove_rectangle;
paned = GTK_PANED (widget);
border_width = GTK_CONTAINER (widget)->border_width;
+ if (paned->child1)
+ gtk_widget_get_child_requisition (paned->child1, &child1_requisition);
+ else
+ child1_requisition.height = 0;
+
+ if (paned->child2)
+ gtk_widget_get_child_requisition (paned->child2, &child2_requisition);
+ else
+ child2_requisition.height = 0;
+
gtk_paned_compute_position (paned,
widget->allocation.height
- paned->gutter_size
- 2 * border_width,
- paned->child1 ? paned->child1->requisition.height : 0,
- paned->child2 ? paned->child2->requisition.height : 0);
+ child1_requisition.height,
+ child2_requisition.height);
/* Move the handle before the children so we don't get extra expose events */
gtk_widget_size_request (GtkWidget *widget,
GtkRequisition *requisition)
{
- GtkWidgetAuxInfo *aux_info;
-
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
+#ifdef G_ENABLE_DEBUG
+ if (!GTK_WIDGET_TOPLEVEL (widget) && (requisition == &widget->requisition))
+ g_warning ("gtk_widget_size_request() called on child widget with widget equal\n to widget->requisition. gtk_widget_set_usize() may not work properly.");
+#endif /* G_ENABLE_DEBUG */
+
gtk_widget_ref (widget);
gtk_widget_ensure_style (widget);
gtk_signal_emit (GTK_OBJECT (widget), widget_signals[SIZE_REQUEST],
- requisition);
+ &widget->requisition);
+
+ if (requisition)
+ gtk_widget_get_child_requisition (widget, requisition);
+
+ gtk_widget_unref (widget);
+}
+
+/*****************************************
+ * gtk_widget_get_requesition:
+ *
+ * arguments:
+ *
+ * results:
+ *****************************************/
+
+void
+gtk_widget_get_child_requisition (GtkWidget *widget,
+ GtkRequisition *requisition)
+{
+ GtkWidgetAuxInfo *aux_info;
+
+ g_return_if_fail (widget != NULL);
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
+ *requisition = widget->requisition;
+
aux_info = gtk_object_get_data_by_id (GTK_OBJECT (widget), aux_info_key_id);
if (aux_info)
{
if (aux_info->height > 0)
requisition->height = aux_info->height;
}
- gtk_widget_unref (widget);
}
/*****************************************
GtkRequisition old_requisition;
old_requisition = widget->requisition;
- gtk_widget_size_request (widget, &widget->requisition);
+ gtk_widget_size_request (widget, NULL);
if ((old_requisition.width != widget->requisition.width) ||
(old_requisition.height != widget->requisition.height))
GtkRequisition *requisition);
void gtk_widget_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
+void gtk_widget_get_child_requisition (GtkWidget *widget,
+ GtkRequisition *requisition);
void gtk_widget_add_accelerator (GtkWidget *widget,
const gchar *accel_signal,
GtkAccelGroup *accel_group,
if (bin->child && GTK_WIDGET_VISIBLE (bin->child))
{
- gtk_widget_size_request (bin->child, &bin->child->requisition);
+ GtkRequisition child_requisition;
+
+ gtk_widget_size_request (bin->child, &child_requisition);
- requisition->width += bin->child->requisition.width;
- requisition->height += bin->child->requisition.height;
+ requisition->width += child_requisition.width;
+ requisition->height += child_requisition.height;
}
else
{
if (info && info->width > 0)
{
- size_changed = size_changed || (width != info->width);
+ size_changed = size_changed || (width != info->last_width);
info->last_width = width;
new_width = info->width;
}
if (info && info->height > 0)
{
- size_changed = size_changed || (height != info->height);
+ size_changed = size_changed || (height != info->last_height);
info->last_height = height;
new_height = info->height;
}
gtk_widget_show (label);
handle_box = gtk_handle_box_new ();
- gtk_container_add (GTK_CONTAINER (hbox), handle_box);
+ gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (handle_box),
"child_attached",
GTK_SIGNAL_FUNC (handle_box_child_signal),
gtk_widget_show (toolbar);
handle_box = gtk_handle_box_new ();
- gtk_container_add (GTK_CONTAINER (hbox), handle_box);
+ gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (handle_box),
"child_attached",
GTK_SIGNAL_FUNC (handle_box_child_signal),
gtk_widget_show (label);
handle_box = gtk_handle_box_new ();
- gtk_container_add (GTK_CONTAINER (hbox), handle_box);
+ gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (handle_box),
"child_attached",
GTK_SIGNAL_FUNC (handle_box_child_signal),
gtk_widget_show (toolbar);
handle_box = gtk_handle_box_new ();
- gtk_container_add (GTK_CONTAINER (hbox), handle_box);
+ gtk_box_pack_start (GTK_BOX (hbox), handle_box, FALSE, FALSE, 0);
gtk_signal_connect (GTK_OBJECT (handle_box),
"child_attached",
GTK_SIGNAL_FUNC (handle_box_child_signal),
projects / gtk4.git / commitdiff